<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Chapter&nbsp;4.&nbsp;面向图的程序设计</title>
    <link rel="stylesheet" href="css/html.css" type="text/css">
    <meta name="generator" content="DocBook XSL Stylesheets V1.65.1">
    <link rel="home" href="index.html" title="JBoss jBPM 3.1">
    <link rel="up" href="index.html" title="JBoss jBPM 3.1">
    <link rel="previous" href="tutorial.html" title="Chapter&nbsp;3.&nbsp;教程">
    <link rel="next" href="deployment.html" title="Chapter&nbsp;5.&nbsp;部署（Deployment）">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="navheader">
    <table width="100%" summary="Navigation header">
        <tr>
            <th colspan="3" align="center">Chapter&nbsp;4.&nbsp;面向图的程序设计</th>
        </tr>
        <tr>
            <td width="20%" align="left"><a accesskey="p" href="tutorial.html">Prev</a>&nbsp;</td>
            <th width="60%" align="center">&nbsp;</th>
            <td width="20%" align="right">&nbsp;<a accesskey="n" href="deployment.html">Next</a></td>
        </tr>
    </table>
    <hr>
</div>
<div class="chapter" lang="cn">
<div class="titlepage">
    <div>
        <div><h2 class="title"><a name="graphorientedprogramming"></a>Chapter&nbsp;4.&nbsp;面向图的程序设计
        </h2></div>
    </div>
    <div></div>
</div>
<div class="section" lang="cn">
<div class="titlepage">
    <div>
        <div><h2 class="title" style="clear: both"><a name="gopintroduction"></a>4.1.&nbsp;简介</h2></div>
    </div>
    <div></div>
</div>
<p> 这章可以看作是JBoss jBPM的manifest。它给出了一个完整的远景概览、当前策略后的想法以及关
    于JBoss jBPM项目的更多说明。这一远景明显不同于传统做法.
</p>

<p> 首先，我相信多流程语言同时存在。有不同的环境及不同的目的，需要一个他们自己特定的流程语言。
</p>

<p>第二, 面向图的程序设计是一项新的实现技术，可以作为一个基础服务所有基于图的流程语言。
</p>

<p> 我们采用的方法的主要优点是它为所有类型的流程语言定义了一项基本技术。
</p>

<p> 当前的软件开发越来越依赖于特定业务领域的语言。一个典型的Java开发人员会用到好几种特定语言。
    那些由种类繁多的框架引入到项目中的XML文件就可以看作是领域特定语言。
</p>

<div class="figure"><a name="languages.overview.image"></a>

    <div class="mediaobject" align="center"><img src="images/languages.overview.jpg" align="middle"
                                                 alt="基于图的语言的位置"></div>
    <p class="title"><b>Figure&nbsp;4.1.&nbsp;基于图的语言的位置</b></p></div>
<p> 工作流、BPM、orchestration 和 pageflow 的领域特定语言都是基于在一个有向图上运行的。
    其他如hibernate的映射文件，ioc配置文件不是。面向图的程序设计是所有基于运行一个图的领域特定语言的基础。
</p>

<p>面向图的程序设计是一项非常简单的技术，他描述如何定义图和在简单面向对象程序设计语言中运行图。
</p>

<p>在 <a href="graphorientedprogramming.html#applicationdomains" title="4.5.&nbsp;Application domains">Section&nbsp;4.5,
    &#8220;应用领域&#8221;</a>, 我们会覆盖大部分经常用到的流程语言，都可以被实现为使用面向图的程序设计，如工作流，BPM，orchestration
    和 pageflow.
</p>

<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="domainspecificlanguages"></a>4.1.1.&nbsp;领域特定语言</h3>
            </div>
        </div>
        <div></div>
    </div>
    <p> 每一个流程语言都可以看作是领域特定语言(DSL)。从DSL的角度了开发人员可以很好的了解到流程语
        言是如何与普通的面向对象程序设计联系起来的。
    </p>

    <p>本节可能会使人觉得我们只是纯粹把焦点放在在编程环境上。完全不是这样。面向图的程序设计包括了
        整个BPM产品的方面，从API库到整个成型的BPM产品套件。BPM产品套件是完全以业务流程为中心的
        软件开发环境。在这类产品中，是尽量避免要去用语言来编写程序的。
    </p>

    <p> 领域特定语言的一个重要方面是每个语言都有一些自己的语法。这些语法可以解释为领域模型。在java
        中这是类、方法、属性和构造器...；在jPDL中是节点、迁移路径、动作...；在规则引擎中，这是条件、推论...。
    </p>

    <p> DSL的主要思想是开发人员用特定语言编写作品的时候用这些语法来进行思考。IDE是围绕着一种语言的
        语法来构建的。这样，就有不同的编辑器来编写不同的作品。例如，一个jPDL流程有一个图形化编辑器
        和一个XML源文件查看器。另外，也可以用不同的方式来存储这些作品：jPDL中，这应该是一个流程定
        义XML文件或一系列节点和迁移路径对象的图。另一个例子（理论）是java:你可以在系统中使用java
        类文件格式。当一个用户启动编辑器，产生源代码。当用户保存的时候，保存已经编译好的class...
    </p>

    <p>10年前，开发人员花费把最多的时间花在编写代码上面。现在已经转变为学习和使用领域特定语言。这种
        趋势仍将继续，结果是开发者可以有很多的框架选择，并在主机平台上编写软件。JBoss SEAM在这个方
        向上走了一大步。
    </p>

    <p>这些语言中的某些是基于执行一个图的。例如，java中用于工作流的jPDL，服务构件的BPEL，SEAM的pageflow...
        面向图的程序设计是这些类型的领域特定语言的通用基础。
    </p>

    <p>将来，每种语言，开发人员都可以选择一个最适合他/她的编辑器。例如，一个很厉害的程序员可能会直接
        编辑源文件，因为这样很快。但是一个经验不是很够的java开发人员可能会选择点击编辑器来建立一个
        java类及其功能。java源代码编辑器会有更大的弹性。
    </p>

    <p>另一方面，从构建软件的角度看这些特定领域语言(包括编程语言)。面向对象编程语言（OOP）添加了把数
        据和方法分组的结构。面向方面程序设计(AOP)加入提取交叉关切的方式。依赖注射(DI)和控制反转(IoC)
        框架增添易于连接的对象图。基于图形执行语言(这里谈论的这些)可帮助解决复杂的软件构建，通过围绕
        执行图构建你的软件项目的一部分。
    </p>

    <p>一个最初的领域特定语言(DSL)的解释可以在这里找到：
        <a href="http://www.martinfowler.com/bliki/DomainSpecificLanguage.html" target="_top">on Martin Fowler's
            bliki</a>. 但是后面的这个版本会更加详细：
        <a href="http://www.martinfowler.com/articles/languageWorkbench.html" target="_top">Martin's article about
            'Language Workbenches'</a>.
    </p></div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h3 class="title"><a name="featuresofgraphbasedlanguages"></a>4.1.2.&nbsp;基于图的语言的特性</h3></div>
        </div>
        <div></div>
    </div>
    <p>有许多种基于图形的流程语言，他们之间在环境和焦点方面都有很大的不同。比如说，BPEL是致力于一种在企
        业服务总线（Enterprise Service Bus-ESB）架构下的基于XML的提供服务组件。一种pageflow流程语
        言可能定义web引用的页面怎么导航。这是两种完全不同的环境。
    </p>

    <p>尽管有这些不同，但是你会发现几乎所有流程语言都有两个特性：支持等待状态和图形化表示。这并非偶然,
        因为这两个特点,恰恰是普通面向对象编程语言（Object Oriented (OO) programming）支持不够的，譬如java。
    </p>

    <p>面向图的程序设计是一项在面向对象编程语言中实现这两个特性的技术。面向图的程序设计对面向对象编程语言
        的依赖暗示着，所有具体的在面向图的程序设计之上实现的流程语言，都要用OOP来开发。但这不意味着流程语
        言本身暴露任何这种OOP本质。例如，BPEL与OOP没有任何关系，也可以在GOP上实现。
    </p>

    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h4 class="title"><a name="supportforwaitstates"></a>4.1.2.1.&nbsp;支持等待状态</h4>
                </div>
            </div>
            <div></div>
        </div>
        <p>命令式编程语言，譬如java，是用来表达一系列要在一个系统上运行的指令，没有等待指令。例如，命令式语
            言用在描述服务器的请求/响应周期里是很合适的。系统一直运行这些指令序列，直到请求被处理，完成一个
            响应。
        </p>

        <p>但是这样的一个请求，典型地，是一个更大场景的一部分。例如，一个客户端提交购买订单，这个购买订单是
            由订单管理员确认的。通过审批后，这些信息必须输入到ERP系统中。到达服务器的很多请求，是同样这个
            更大场景的一部分。
        </p>

        <p>所以，流程语言是用来描述这种更大的场景的语言。这里要指出的一个非常重要的区别是运行在一个系统的场
            景(orchestration)和描述多个系统(choreography)之间的协议的场景。面向图的程序设计实现技术只把
            目标放在运行在一个机器(orchestration)上的流程语言。
        </p>

        <p>所以，一个orchestration流程描述所有在一个系统上运行的场景。例如：一个流程在客户提交订单的时候启
            动。流程的下一步是订单管理员审批，因此系统必须给订单管理员的任务列表添加一个条目并<span class="bold"><b>等待（wait）</b></span>
            直到订单管理员提供了必须的输入信息。收到输入信息的后，流程继续执行。现在一个信息发送到ERP系统，
            然后系统再次<span class="bold"><b>等待（wait）</b></span>直到响应回来。
        </p>

        <p>因此，要描述一个系统完整的场景，我们需要一个处理等待状态的机制。
        </p>

        <p> 在大部分应用领域中，执行状态在等待状态中必须持久化，这就是为什么阻塞线程不好用的地方。聪明的Java程序员
            可能会想到Object.wait() 和 Object.notify()两个方法。那可以用来模拟等待状态，但问题是那个线程是不能
            持久化的。
        </p>

        <p>续前技术（Continuations）是一项使线程（以及上下文变量）能够被持久化的技术。这项技术可能解决等待状态的问题。
            但就像我们将会在下一节谈到的一样，图形化表示在很多应用领域中也是相当重要的。同时，续前技术（Continuations）
            是基于命令式编程的，所以它不适合与图形化表示。
        </p>

        <p>因此支持等待状态执行信息的可持久化是一个重要的方面。对于执行信息的持久化，不同的应用领域可能会有不同的需求。
            大部分工作流，BPM和orchestration应用，其执行信息需要持久化到关系数据库中。通常流程执行的状态迁移与数据
            库的一个事务对应。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h4 class="title"><a name="graphicalrepresentation"></a>4.1.2.2.&nbsp;图形化表示</h4>
                </div>
            </div>
            <div></div>
        </div>
        <p>软件开发的某些方面可以非常得益于基于图的方法。业务流程管理是其中最显而易见的基于图的语言的应用领域。
            在上面的例子中，业务分析人员和开发人员之间的沟通通过使用业务流程图这种基于图的语言得到了提升。
            更多信息请看<a href="graphorientedprogramming.html#bpm"
                     title="4.5.1.&nbsp;Business Process Management (BPM)">Section&nbsp;4.5.1,
            &#8220;业务流程管理 (BPM)&#8221;</a>
        </p>

        <p>另一个可以得益于图形化表示的方面是pageflow。在这种情况下,页面、导航和动作命令在图形化表示中一起显示和链接的。
        </p>

        <p>在面向图的程序设计中，我们把目标放在表示某些格式的执行信息的图上。这是非常不同的，例如与UML类图，类图表示
            面向对象数据结构的静态模型。
        </p>

        <p>我们也可以把图形化表示看作是面向对象编程缺失的一个特性。没有一个明智的方法可以图形化表示一个面向对象程序的执行。
            所以在面向对象程序和图形视图之间没有直接联系。
        </p>

        <p>在面向图的程序设计中，对图的描述是集中的，它是一个真正的软件艺术品，例如，一个描述流程图的XML文件。
            由于图形化视图是是软件固有的部分，因此它总是同步的。不需要人工转换图形需求到软件设计。软件已经围绕
            着图构建好了。
        </p></div>
</div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="gop"></a>4.2.&nbsp;面向图的程序设计</h2></div>
        </div>
        <div></div>
    </div>
    <p>这里我们展示的是一个基于图的执行的语言的实现技术。这项技术是运行时解释图的。执行图的其他技术是基于消息队列或者代码生成的。
    </p>

    <p>本节将讲解如何在OO语言中实现执行图策略。对于熟识设计模式的读者，它是命令模式和责任链模式的组合。
    </p>

    <p>我们将从可能的最简单的模型做起，然后一点一点地扩展它。
    </p>

    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="thegraphstructure"></a>4.2.1.&nbsp;图的结构</h3></div>
            </div>
            <div></div>
        </div>
        <p>首先，图的结构是用类
            <tt class="literal">Node</tt> 和 <tt class="literal">Transition</tt>来表示的。Transition是有方向的
            所以一个节点会有离开和到达的Transition
        </p>

        <div class="figure"><a name="node.transition.classes.image"></a>

            <div class="mediaobject" align="center"><img src="images/node.transition.classes.gif" align="middle"
                                                         alt="Node and Transition classes"></div>
            <p class="title"><b>Figure&nbsp;4.2.&nbsp;Node 和 Transition 类</b></p></div>
        <p>node是一个命令，并有一个 <tt class="literal">execute</tt> 方法。Node的子类通过重载execute方法
            来实现其他一些节点类型的特定行为。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="anexecution"></a>4.2.2.&nbsp;执行（execution）</h3></div>
            </div>
            <div></div>
        </div>
        <p> 我们为这个图结构定义的执行模型看起来像状态机或者UML状态图。实际上，面向图的程序设计可以用来实现那些类型
            的行为，但它还能做到更多事情。
        </p>

        <p>执行(也叫令牌（token）)由一个叫
            <tt class="literal">Execution</tt>的类表示。执行有一个指向当前节点的参考指针。
        </p>

        <div class="figure"><a name="execution.class.image"></a>

            <div class="mediaobject" align="center"><img src="images/execution.class.gif" align="middle"
                                                         alt="Execution 类"></div>
            <p class="title"><b>Figure&nbsp;4.3.&nbsp;Execution 类</b></p></div>
        <p>Transitions可以通过方法<tt class="literal">take</tt>把execution从源节点传递到目标节点。
        </p>

        <div class="figure"><a name="transition.take.method.image"></a>

            <div class="mediaobject" align="center"><img src="images/transition.take.method.gif" align="middle"
                                                         alt="Transition的 take 方法"></div>
            <p class="title"><b>Figure&nbsp;4.4.&nbsp;Transition的 take 方法</b></p></div>
        <p>当一个execution到达一个节点，该节点被执行。节点对象的execute方法还要负责继续传播execution。传播
            表示节点可以把到达节点的execution通过其中一个transition传递到下一个节点。
        </p>

        <div class="figure"><a name="node.execute.method.image"></a>

            <div class="mediaobject" align="center"><img src="images/node.execute.method.gif" align="middle"
                                                         alt="节点的execute 方法"></div>
            <p class="title"><b>Figure&nbsp;4.5.&nbsp;节点的execute 方法</b></p></div>
        <p>当一个节点的execute方法没有传播execution的时候，就表现为一个等待状态。即使一个execution是新创建的，
            也是在某个开始节点初始化然后等待一个事件。
        </p>

        <p>事件被分派给execution，它可以触发execution开始移动。如果给execution制定的事件是与当前节点的一个
            离开transition相关联的，execution会选用那个transition。然后execution会一直继续传播，直到进入
            另外一个表现为等待状态的节点。
        </p>

        <div class="figure"><a name="execution.event.method.image"></a>

            <div class="mediaobject" align="center"><img src="images/execution.event.method.gif" align="middle"
                                                         alt="Execution的 event 方法"></div>
            <p class="title"><b>Figure&nbsp;4.6.&nbsp;Execution的 event 方法</b></p></div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="aprocesslanguage"></a>4.2.3.&nbsp;流程语言</h3></div>
            </div>
            <div></div>
        </div>
        <p>所以现在我们已经可以看到,支持的两个主要特点是:等待状态和图形化表示。在等待状态时，一个Execution只是指向
            图中的一个节点。流程图和Execution都可以被持久化：例如，通过一个类似hibernate 的O/R映射持久化到关系数
            据库，或者序列化对象图到文件。另外你也可以看到节点和transition组成一个图，因此和图形化表示有直接关联。
        </p>

        <p> 图形语言不是什么其他东西，它只是一组节点的实现。每个节点实现对应一个流程构造部分。具体的流程构造部分的行
            为是通过重载execute方法来实现的。
        </p>

        <p>这里我们展示一个有4个流程构造部分的流程语言：一个开始状态节点（start state），一个决定节点（decision），一
            个任务（task）及节点以及一个结束状态（end state）节点。这个例子与jPDL流程语言无关。
        </p>

        <div class="figure"><a name="example.process.language.image"></a>

            <div class="mediaobject" align="center"><img src="images/example.process.language.jpg" align="middle"
                                                         alt="一个流程语言的例子"></div>
            <p class="title"><b>Figure&nbsp;4.7.&nbsp;一个流程语言的例子</b></p></div>
        <p>具体节点对象现在可以用来创建流程图了。
        </p>

        <div class="figure"><a name="example.process.image"></a>

            <div class="mediaobject" align="center"><img src="images/example.process.jpg" align="middle"
                                                         alt="一个流程例子"></div>
            <p class="title"><b>Figure&nbsp;4.8.&nbsp;一个流程例子</b></p></div>
        <p>当为这个流程创建一个新的execution的时候，我们把execution定位在开始节点。这样只要execution没有收到
            事件，就会停留在开始节点上。
        </p>

        <div class="figure"><a name="new.execution.image"></a>

            <div class="mediaobject" align="center"><img src="images/new.execution.jpg" align="middle"
                                                         alt="一个新的 execution"></div>
            <p class="title"><b>Figure&nbsp;4.9.&nbsp;一个新的 execution</b></p></div>
        <p> 现在我们来看看当触发事件的时候会发生什么事情。在个初始状态下，我们触发缺省事件，这对应于缺省transition。
        </p>

        <p>这是通过调用execution对象的event方法来实现的。event方法会找到缺省的离开transition，然后把execution
            通过调用transition的take方法把execution传递到下一个节点，同时也把自己作为参数传递进去。
        </p>

        <p>transition会把execution传递下来给decision节点，同时调用execute方法。让我们假定decision的execute实现
            经过计算然后决定通过发出'yes'事件给execution把execution传递下去。那会导致execution通过'yes' transition
            继续，并到达任务节点'doubleCheck'。
        </p>

        <p>让我们假设doubleCheck任务节点的execute实现是把一个任务添加到checker的任务列表然后等待checker的输入，
            不在继续传播execution。
        </p>

        <p> 现在，execution会留在doubleCheck任务节点上。所有内嵌的调用会开始返回，直到原事件方法返回。
            （All nested invocations will start to return until the original event method returns.)
        </p>

        <div class="figure"><a name="wait.state.image"></a>

            <div class="mediaobject" align="center"><img src="images/wait.state.jpg" align="middle"
                                                         alt="execution在'doubleCheck'节点的等待状态"></div>
            <p class="title"><b>Figure&nbsp;4.10.&nbsp;execution在'doubleCheck'节点的等待状态</b></p></div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="gopactions"></a>4.2.4.&nbsp;Actions</h3></div>
            </div>
            <div></div>
        </div>
        <p>在某些应用领域，会有一种不用引入节点而加入程序运行逻辑的方法。例如，在业务流程管理中这是一个非常重要的方面。
            业务分析人员负责流程的图形化表示，开发人员负责使流程可以跑起来。如果开发人员因为要包含一个业务分析人员并不
            感兴趣的技术细节而要更改流程图，那是不可接受的。
        </p>

        <p><tt class="literal">Action</tt>也是一个带有execute方法的命令。Action可以与event连结起来。
        </p>

        <p> 当一个execution运行的时候，有2中基本的事件会由Node类发出：<tt class="literal">node-leave</tt> 和
            <tt class="literal">node-enter</tt>。
            和引起被选择的transition的event一起，这已经给予了一个很自由的方式使得可以注入程序逻辑到图的执行过程中。
        </p>

        <div class="figure"><a name="hidden.actions.image"></a>

            <div class="mediaobject" align="center"><img src="images/hidden.actions.jpg" align="middle"
                                                         alt="action通常会隐藏在流程图的后面">
            </div>
            <p class="title"><b>Figure&nbsp;4.11.&nbsp;action通常会隐藏在流程图的后面</b></p>
        </div>
        <p> 每个event都可以添加一个action列表。事件触发的时候所有这些action都会被运行。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="codeexample"></a>4.2.5.&nbsp;代码例子</h3></div>
            </div>
            <div></div>
        </div>
        <p>为了让读者能够得到一个对面向图的程序设计的直观认识，我们用少于130行的代码开发了4个类。你可以只是读这些代码
            以便获得认识，或者你可以真的开始试试他们并实现你自己的节点类型。
        </p>

        <p>例子代码：
        </p>

        <div class="itemizedlist">
            <ul type="disc">
                <li><a href="gop/Execution.java.html" target="_top"><span class="bold"><b><tt
                        class="literal">Execution.java</tt></b></span></a></li>
                <li><a href="gop/Node.java.html" target="_top"><span class="bold"><b><tt
                        class="literal">Node.java</tt></b></span></a></li>
                <li><a href="gop/Transition.java.html" target="_top"><span
                        class="bold"><b><tt class="literal">Transition.java</tt></b></span></a></li>
                <li><a href="gop/Action.java.html" target="_top"><span class="bold"><b><tt
                        class="literal">Action.java</tt></b></span></a></li>
            </ul>
        </div>
        <p>你还可以<a href="gop/jbpm.gop.zip" target="_top">下载整个项目的源代码(297KB)
            </a> 并开始自己试试他们。它包含了一个eclipse的项目，所以只要作为一个项目导入到你的eclipse就可以开始了。还有一组测试
            展示了基本的流程执行和高级流程执行概念（下一节谈到）。
        </p></div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="advancedgop"></a>4.3.&nbsp;高级面向图的程序设计扩展</h2></div>
        </div>
        <div></div>
    </div>
    <p>上一节介绍了最简单的面向图的程序设计模型。这一节讨论面向图的语言的更多方面，以及面向图的程序设计如何扩展来
        满足这些需求。
    </p>

    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="d0e1293"></a>4.3.1.&nbsp;流程变量</h3></div>
            </div>
            <div></div>
        </div>
        <p>流程变量维护上下文相关的流程执行信息。在一个保险索赔的流程中，“索赔金额”、“核定金额”和“是否已经支付”
            就是变量流程的一个良好的例子。在许多方面，他们与类的成员变量类似。
        </p>

        <p>通过与流程执行相关的名-值对建立联系，面向图的程序设计可以很容易地扩展成可以支持流程变量。
            <a href="graphorientedprogramming.html#concurrentexecutions" title="4.3.2.&nbsp;并行执行">并行执行路径</a> 和
            <a href="">流程组合</a>
            可能会使事情变得稍微复杂一点。在并行流程的子流程路径这种情况中，范围规则会定义流程变量的可见性。
        </p>

        <p><a href="http://is.tm.tue.nl/research/patterns/download/data_patterns%20BETA%20TR.pdf" target="_top">'工作流数据模式'</a>
            是一个针对可以应用到并行流程和子流程的流程变量中的范围类型的研究报告。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="concurrentexecutions"></a>4.3.2.&nbsp;并行执行</h3></div>
            </div>
            <div></div>
        </div>
        <p>假设你在用工作流的基于图的流程语言开发一个“销售”流程。在客户提交了订单之后，会有一系列客户付款
            和装运发货给客户的活动需要进行。正如你想象的一样，付款和装运两个活动是可以并行进行的。
        </p>

        <p>在这种情况中，一个execution就不够用来跟踪整个流程的状态了。让我们来过一下扩展面向图的程序设计模型，
            以使他可以支持并行流程的步骤。
        </p>

        <p>首先，让我们把执行改名为执行路径。然后带出一个新的概念——流程执行。一个
            流程执行表示一个流程的完整的执行，它包含许多执行路径。
        </p>

        <p>执行路径可以层次化分布。这意味着，当一个新的流程初始化的时候，创建一个根执行路径，当
            根执行路径分叉(fork)为多个并行执行路径，根执行路径是所有新创建执行路径的父执行路径。利用这
            种方法，流程汇合（join）的实现就变得很简单直接了：汇合（join）的实现只需要检查是否所有的兄
            弟执行路径都已经跑到汇合（join）节点。如果都已经到达，那么父执行路径可以恢复执行，离开汇合
            （join）节点。
        </p>

        <p>尽管层次化的执行路径和基于兄弟执行路径的汇合（join）实现已经覆盖了很大一部分用户使用情况，但是
            其他的并行行为在某些特定的情况下也可能是可取的。例如，一个分发的节点，多个汇合节点，其他运行时
            数据的组合和汇合实现是需要的。
        </p>

        <div class="figure"><a name="concurrent.executions.image"></a>

            <div class="mediaobject" align="center"><img src="images/concurrent.executions.jpg" align="middle"
                                                         alt="通常躲在流程图后面的动作（action）">
            </div>
            <p class="title"><b>Figure&nbsp;4.12.&nbsp;通常躲在流程图后面的动作（action）</b></p>
        </div>
        <p>多个并行执行路径经常和多线程编程的概念混淆。特别是在工作流和BPM中，这是非常不一样的。流程指定了一个状态机。
            想一想一个状态机始终处于稳定状态, 状态跃迁是instantanious的. 然后你可以通过观察引起状态跃迁的时间解释
            执行的并行路径。这样并行执行意味着可以处理的事件在并行执行路径之间是没有联系的。现在让我们来假定流程执行
            的状态跃迁和数据库的转换是有关系的（跟在<a href="graphorientedprogramming.html#persistenceandtransactions"
            title="4.3.6.&nbsp;Persistence and Transactions">Section&nbsp;4.3.6, &#8220;持久化和事务&#8221;</a>
            中解释的一样），这样你就明白了多线程编程在流程并行执行中甚至不是真正必须的。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="processcomposition"></a>4.3.3.&nbsp;流程组合</h3></div>
            </div>
            <div></div>
        </div>
        <p>流程组合是指一个流程包含子流程的能力。这个高级特性使得为流程建模增加抽象成为可能。对于业务分析来说
            ，这个特性可以把大的模型分解为小的模块，这是非常重要的。
        </p>

        <p>主要的思想是流程中可以有一个节点，该节点可以表示一个子流程的完整执行。当一个执行进入流程的子流程的时候，
            有几个事情是需要考虑的：
        </p>

        <div class="itemizedlist">
            <ul type="disc">
                <li>首先，要为子流程创建一个新的执行。
                </li>
                <li>可选地，一些存储在流程变量中的信息，可以从流程执行中注入到子流程的执行中。最简单的方式是，子流程
                    节点被配置一组变量，这组变量是简单的从父流程的变量中复制的。
                </li>
                <li>子流程的开始节点应该只有一个离开的跃迁。支持多个离开跃迁的流程语言必须有一个机制可以根据父流程的
                    流程变量来从多个跃迁中选择一个。
                </li>
                <li>子流程的执行是通过触发一个和它的开始节点的缺省离开跃迁的事件来发起的。
                </li>
            </ul>
        </div>
        <p> 子流程进入等待状态后，父流程的执行会指向子流程节点，而子流程的执行会指向某个等待状态。
        </p>

        <p> 当子流程执行完成后，父流程的执行便可继续了。这时候有如下几个方面需要进行考虑：
        </p>

        <div class="itemizedlist">
            <ul type="disc">
                <li>流程变量的信息可能需要从子流程复制回父流程。
                </li>
                <li>父流程的执行应该继续。通常，流程语言会只允许子流程节点有一个离开的跃迁。这样父流程的执行就能
                    从这个缺省的（唯一的）跃迁离开。
                </li>
                <li>如果子流程节点允许多个离开跃迁，必须引入机制去选择一个离开跃迁。这个选择可以基于子流程的变量，
                    也可以基于子流程的结束状态（一个典型的状态机能有多个结束状态）。
                </li>
            </ul>
        </div>
        <p>TODO: BPEL有隐含而非明确说明的子流程概念...
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="d0e1362"></a>4.3.4.&nbsp;同步执行</h3></div>
            </div>
            <div></div>
        </div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="d0e1365"></a>4.3.5.&nbsp;异步执行（Asynchronous continuations）</h3></div>
            </div>
            <div></div>
        </div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="persistenceandtransactions"></a>4.3.6.&nbsp;持久化和事务
                </h3></div>
            </div>
            <div></div>
        </div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="d0e1371"></a>4.3.7.&nbsp;服务和环境</h3></div>
            </div>
            <div></div>
        </div>
    </div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="architecture"></a>4.4.&nbsp;架构</h2></div>
        </div>
        <div></div>
    </div>
    <p>
    </p></div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="applicationdomains"></a>4.5.&nbsp;应用领域
            </h2></div>
        </div>
        <div></div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="bpm"></a>4.5.1.&nbsp;业务流程管理(BPM)</h3></div>
            </div>
            <div></div>
        </div>
        <p>BPM的目的是要使组织机构的运转更有效率。第一步是分析和表述工作在组织机构中是如何进行的。让我们定义一下，
            业务流程就是人员和系统一起协同工作以达成意见工作的描述。一旦业务流程描述好，就可以开始研究如何进行优化了。
        </p>

        <p>有时业务流程已经有机的演化了，以及只是从整体业务来看某些地方明显缺乏效率。研究如何改变这些流程以使得更有效
            率叫企业流程再造。一旦大部分的业务流程都已经自动化了，就可以统计和稽核以帮助找到并指出这些缺乏效率的点。
        </p>

        <p> 另一个提高效率的方法是使用信息技术来自动化全部或部分业务流程。
        </p>

        <p> 自动化和变更业务流程是提升组织机构效率最常用的方法。
        </p>

        <p> 管理者持续地分解工作到每一步以便由团队成员来执行。例如，一个软件开发经理组织一个团队建设事件。在这种情况下，
            业务流程的描述可能是只由经理的头儿来做。在其他情况下，如为一个大的保险公司处理保险理赔，需要一个更加正式的
            方法来处理BPM。
        </p>

        <p> 可以从管理业务流程获得的总的收益是效率的提高、节省时间和执行流程。业务流程管理的附加花费在分析、描述、
            提高和自动化业务流程上。所以当决定为正规化管理和自动化操作采用哪个流程的时候，这些花费应该也要纳入考虑。
        </p>

        <div class="section" lang="cn">
            <div class="titlepage">
                <div>
                    <div><h4 class="title"><a name="d0e1397"></a>4.5.1.1.&nbsp;BPM系统的目的</h4></div>
                </div>
                <div></div>
            </div>
        </div>
        <div class="section" lang="cn">
            <div class="titlepage">
                <div>
                    <div><h4 class="title"><a name="d0e1400"></a>4.5.1.2.&nbsp;流程开发过程</h4></div>
                </div>
                <div></div>
            </div>
        </div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="d0e1403"></a>4.5.2.&nbsp;服务组合（Service orchestration）</h3></div>
            </div>
            <div></div>
        </div>
        <p>orchestration 有时也被成为服务组合.
        </p>

        <div class="figure"><a name="service.orchestration.image"></a>

            <div class="mediaobject" align="center"><img src="images/service.orchestration.jpg" align="middle"
                                                         alt="Service"></div>
            <p class="title"><b>Figure&nbsp;4.13.&nbsp;服务 </b></p></div>
        <div class="section" lang="cn">
            <div class="titlepage">
                <div>
                    <div><h4 class="title"><a name="d0e1414"></a>4.5.2.1.&nbsp;Orchestration 与 Choreography的对比
                    </h4></div>
                </div>
                <div></div>
            </div>
        </div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="d0e1417"></a>4.5.3.&nbsp;Pageflow</h3></div>
            </div>
            <div></div>
        </div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="d0e1420"></a>4.5.4.&nbsp;可视化编程</h3></div>
            </div>
            <div></div>
        </div>
        <p>...针对较少经验的开发人员。</p>

        <p>我认为，当前的java社区相对而言只是一小部分能力非常好的用户的社区。当然，用点击的方式来操作会有
            许多限制，不能处理所有的java结构。但是会为新的（较少经验）软件开发者打开一片新的天空。所以一
            门语言可以有以不同类型/等级的用户使用的不同的编辑器。
        </p></div>
</div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="embeddinggraphbasedlanguages"></a>
                4.6.&nbsp;嵌入式的基于图的语言（Embedding graph based languages）</h2></div>
        </div>
        <div></div>
    </div>
    <p> 当一个BPM引擎可以完全整合到一个软件开发项目，甚至BPM引擎的数据库表也可以整合到项目的数据库，我们说这是一个
        嵌入式的BPM引擎。那就是我们为面向图的程序设计定位的目标：一个实现基于图的语言的通用基础。
    </p></div>
<div class="section" lang="cn">
    <div class="titlepage">
        <div>
            <div><h2 class="title" style="clear: both"><a name="market"></a>4.7.&nbsp;市场</h2></div>
        </div>
        <div></div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="theultimateprocesslanguage"></a>4.7.1.&nbsp;终极流程语言</h3></div>
            </div>
            <div></div>
        </div>
        <p>过去，厂商一直在寻找终极的流程语言。方法是为流程语言指定一组构造。每个构造有一个图形表示和运行时行为表现。
            换句话说，每个构造就是流程图中的一个节点类型。流程语言就是一组节点构造。
        </p>

        <p>这里的想法是，开发商尝试寻找一组最适合的流程构造，要用这些构造来组成一个放之四海而皆准的流程语言。
            这一景象今天还能看到，我们称之为“寻找终极流程语言”。
        </p>

        <p>我们认为焦点不应放在尝试寻找终极流程语言上，而是要找到一种通用基础，可以作为不同场景不同环境下流程语言的基础。
            我们下面展示的面向图的编程被看作是这种基础。
        </p></div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="fragmentation"></a>4.7.2.&nbsp;分歧（Fragmentation）</h3></div>
            </div>
            <div></div>
        </div>
        <p>当前工作流的情形，BPM和orchestration解决方案是完全分歧的。在这一节中，我将从两个图表来描述这这些分歧。
            第一个图表叫BPM产品系列，在下一个图片中展示。这一术语原来是Derek Miers 和 Paul Harmon 在 'The 2005 BPM Suites
            Report'中首先提出的。
        </p>

        <p> 左边，你可以看到编程语言。这边的箭头是针对IT开发人员的。编程语言是最灵活的，并且可以完全和特定的软件开发项目集成。
            但是，需要很多的编程来实现业务流程。
        </p>

        <p> 右边，是BPM套件。这些BPM套件是完整的软件开发环境，目标用户为业务分析人员。软件是围绕业务流程来开发的。使用BPM套件
            不需要编程就可创建可运行的软件。
        </p>

        <div class="figure"><a name="bpm.product.continuum"></a>

            <div class="mediaobject" align="center"><img src="images/bpm.product.continuum.jpg" align="middle"
                                                         alt="BPM产品方向图."></div>
            <p class="title"><b>Figure&nbsp;4.14.&nbsp;BPM产品方向图.</b></p></div>
        <p> 传统产品有一点不好。要完整，这些产品倾向于瞄准方向图的极右端。这是有问题的，因为这样的结果是成为非常独立的一块系统，
            很难集成到组合业务流程的OOP软件中去。
        </p>

        <p> 面向图的程序设计可以构建为一个简单的包，可以很好的集成到普通编程环境中。另一方面，这个库可以打包部署到一个服务器上，
            编程一个BPM服务器。然后其他产品和BPM服务器一起组成完整的BPM套件。
        </p>

        <p> 另一个结果是基于面向图的程序设计的解决方案可以把目标放在整个坐标系上。根据不同项目的要求，BPM套件可以剥离定制到右边，
            和软件开发环境整合到一起。
        </p>

        <p> 另一个分歧的方面是应用领域。就如上面所展示的，BPM应用领域和服务组合或者pageflow是完全不同的。传统产品在这方面也是
            把目标放单一应用领域中，而面向图的程序设计可以覆盖整个范围。
        </p>

        <p> 如果我们把这些放到一个图上，就可以清楚看到当前市场的分歧了。在基于图的语言的市场，价格较高而容量较低。
            结合处是开始，这些技术的目标是成为现在分歧和令人迷惑的市场景象的通用基础。
        </p>

        <div class="figure"><a name="two.dim.fragmentation"></a>

            <div class="mediaobject" align="center"><img src="images/two.dim.fragmentation.jpg" align="middle"
                                                         alt="分歧的两个方向."></div>
            <p class="title"><b>Figure&nbsp;4.15.&nbsp;分歧的两个方向.</b></p></div>
    </div>
    <div class="section" lang="cn">
        <div class="titlepage">
            <div>
                <div><h3 class="title"><a name="otherimplementationtechniques"></a>4.7.3.&nbsp;其他实现技术</h3></div>
            </div>
            <div></div>
        </div>
        <p>基于消息系统的。
        </p>

        <p>基于代码生成的。
        </p></div>
</div>
</div>
<div class="navfooter">
    <hr>
    <table width="100%" summary="Navigation footer">
        <tr>
            <td width="40%" align="left"><a accesskey="p" href="tutorial.html">Prev</a>&nbsp;</td>
            <td width="20%" align="center"><a accesskey="u" href="index.html">Up</a></td>
            <td width="40%" align="right">&nbsp;<a accesskey="n" href="deployment.html">Next</a></td>
        </tr>
        <tr>
            <td width="40%" align="left" valign="top">Chapter&nbsp;3.&nbsp;教程&nbsp;</td>
            <td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td>
            <td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;5.&nbsp;部署（Deployment）</td>
        </tr>
    </table>
</div>
</body>
</html>